#pragma once

#ifndef LHJ_CORE_DATA_MODEL_H__
#define LHJ_CORE_DATA_MODEL_H__

#include <stdint.h>
#include <string>
#include <vector>
#include <iostream>

namespace cores
{
    namespace datas
    {
        namespace models
        {
            namespace terminal
            {
                struct LoraConfigItem
                {
                    // ushort lora_id;
                    uint16_t lora_id;
                    // 枪号
                    // uint8_t nozzle_code;
                    uint8_t nozzle_code;
                    // 油品
                    // uint8_t category;
                    uint8_t category;
                    // 屏类型
                    // uint8_t screen_type;
                    uint8_t screen_type;
                };

                // 显示屏帧脚数据解析的返回值
                struct ScreenValData
                {
                    // 金额
                    int amount;
                    // 体积
                    int volume;
                    // 单价
                    int price;
                    // 数据状态，0-正常；1-逻辑推理；9-显示屏数据异常
                    int screen_raw_type;
                };

                /**
                 * @brief 加油交易数据请求次数模型.
                 *
                 * Detailed explanation.
                 */
                struct OilTransReq
                {
                    /* data */
                    // 设备Id
                    // ushort lora_id;
                    uint16_t lora_id;
                    // 枪号
                    // uint8_t nozzle_code;
                    uint8_t nozzle_code;
                    // 油品
                    // uint8_t category;
                    uint8_t category;
                    // 屏类型
                    // uint8_t screen_type;
                    uint8_t screen_type;
                    // 编码器值兑加油量比值
                    // uint8_t rate;
                    uint8_t rate;
                    // 当前请求数据的编号，max_num + 1, 对应lora中的数据编号
                    // ushort current_req_num;
                    uint16_t current_req_num;
                    // 当前请求的保税口数据编号
                    uint16_t current_tax_num;
                    // 是否有新数据
                    bool has_data;
                    // 是否应答
                    bool is_answer;
                    // 未应答次数，超过3次侧进行报警
                    int no_answer_count;
                    // 错误应答次数，超过3次侧进行报警
                    int error_count;
                    // 配置是否错误
                    bool is_config_error;
                };

                /**
                 * @brief 液位移请求模型.
                 *
                 * Detailed explanation.
                 */
                struct OilTanksReq
                {
                    /* data */
                    // 设备Id
                    // uint8_t code;
                    uint8_t code;
                    // 油品
                    // uint8_t category;
                    uint8_t category;
                    // 油罐首地址，寄存器地质
                    // ushort tank_address;
                    uint16_t tank_address;
                    // 是否有新数据
                    bool has_data;
                    // 是否应答
                    bool is_answer;
                    // 未应答次数，超过3次侧进行报警
                    int no_answer_count;
                    // 错误应答次数，超过3次侧进行报警
                    int error_count;
                };

                struct Config
                {
                    // 上传云端时间间隔
                    int to_cloud_duration;
                    // lora轮询周期
                    int lora_token_duration;
                    // 油站编号
                    std::string station_code;
                    // 区域码
                    std::string dept_code;
                    // 串口号
                    std::string dev_name;
                    // 波特率
                    int baud;
                    // 数据位
                    int dataBit;
                    // 液位仪串口号
                    std::string llq_dev_name;
                    // 液位仪波特率
                    int llq_baud;
                    // 液位仪数据位
                    int llq_data_bit;
                    // 是否为调试
                    bool is_test;
                    // 云端数据服务器Ip
                    std::string dataServerIp;
                    // 云端数据服务器Port
                    int dataServerPort;
                    // 发送报警信息的链接
                    std::string warming_url;
                    // config api url
                    std::string config_api_url;
                    // 版本对比的api链接
                    std::string version_api_url;
                    // exe文件的download链接
                    std::string exe_download_url;
                    // 话题名称. 线程间，发布订阅.
                    std::string loraDataTopic;
                    // 发送报警信息的加密字符
                    std::string warming_token;
                    // 是否需要更新
                    bool is_update_config;
                    // 显示屏类型
                    uint8_t screen_type;
                    // lora设备列表，一个油站有多个lora设备, lora_id
                    std::vector<OilTransReq> lora_devices;
                    // 油罐列表，一个油站有多个油罐
                    std::vector<OilTanksReq> oil_tanks;
                    // 是否校验
                    bool crc_check;
                    // 是否自动升级
                    bool auto_upgrade;
                    // 执行文件本地名称
                    std::string exe_file_name;
                    // 执行文件服务器名称
                    std::string exe_server_file_name;
                    // 本地版本号
                    int local_exe_version;
                };

                // 显示屏属性
                struct ScreenProperty
                {
                    /* data */
                    int frame_count;
                    int amout_size;
                    int volume_size;
                    int price_size;
                };

                /**
                 * @brief 加油交易数据实体.
                 *
                 * Detailed explanation.
                 */
                struct OilTransaction
                {
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 数据编号
                    uint16_t data_sn;
                    // 油站编码
                    std::string station_code;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 抬枪时间
                    uint32_t beg_time;
                    // 挂枪时间
                    uint32_t end_time;
                    // 开始加油时间
                    uint32_t trans_beg_time;
                    // 结束加油时间
                    uint32_t trans_end_time;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 加油量
                    uint32_t volume;
                    // 单价
                    uint32_t price;
                    // 交易金额
                    uint32_t amount;
                    // 编码器数值
                    uint32_t encoder_val;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-待发送; 1-已发送
                    uint8_t sort;
                    // 数据类型 0-正常数据; 1-测试数据
                    uint8_t type;
                    // 屏显数据类型 0 - 正常数据；1 - 逻辑推理
                    uint8_t screen_raw_type;
                    // 显示屏类型从1开始
                    uint8_t screen_type;
                    // 屏显原始数据
                    std::string screen_raw_data;
                };

                /**
                 * @brief 最大流水号表模型.
                 *
                 * Detailed explanation.
                 */
                struct SerialNumber
                {
                    /* data */
                    // 设备Id
                    // ushort lora_id;
                    uint16_t lora_id;
                    // 设备Id
                    // u_char nozzle_code;
                    uint8_t nozzle_code;
                    // 交易数据当前编号
                    // ushort trans_max_num;
                    uint16_t trans_max_num;
                    // 报税口数据当前编号
                    uint16_t tax_max_num;

                    SerialNumber() = default;
                    SerialNumber(const uint16_t& lora_id_,
                    const uint8_t& nozzle_code_,
                    const uint16_t& trans_max_num_,
                    const uint16_t& tax_max_num_)
                    : lora_id(lora_id_), nozzle_code(nozzle_code_), trans_max_num(trans_max_num_), tax_max_num(tax_max_num_)
                    {}

                    void print()
                    {
                        std::cout << "lora id:" << lora_id
                                  << "\tnozzle code:" << int(nozzle_code)
                                  << "\ttrans_max_num:" << trans_max_num
                                  << "\ttax_max_num:" << tax_max_num << std::endl;
                    }
                };

                /**
                 * @brief 交易数据上传条目
                 */
                struct TransUploadItems
                {
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 是否完成
                    bool is_end;
                    // 是否应答
                    bool is_answer;
                    // 错误代码，0 - 成功；
                    // ushort error_code;
                    uint16_t error_code;
                };

                /**
                 * @brief 液位仪实时数据
                 */
                struct LlqDataItem
                {
                    // id
                    std::string trans_id;
                    // 设备Id
                    // uint8_t code;
                    uint8_t code;
                    // 枪号
                    // uint8_t category;
                    unsigned char category;
                    // 油高
                    float oil_level;
                    // 水高
                    float water_level;
                    // 温度
                    float temperature;
                    // 总体积
                    float volume;
                    // 油容积
                    float oil_volume;
                    // 水容积
                    float water_volume;
                    // 创建时间
                    uint32_t create_time;
                    // 状态0-未上传；1-已上传
                    // uint8_t sort;
                    uint8_t sort;
                    // 0-正常，1-测试
                    // uint8_t type;
                    uint8_t type;
                };
            }

            namespace server
            {
                struct Config
                {
                    // 数据库ip
                    std::string db_server_ip;
                    // 数据库端口
                    int db_server_port;
                    // 数据库用户名
                    std::string db_usr;
                    // 数据库密码
                    std::string db_pwd;
                    // 数据库名称
                    std::string db_name;
                    // 数据库ip
                    std::string db_test_server_ip;
                    // 数据库端口
                    int db_test_server_port;
                    // 数据库用户名
                    std::string db_test_usr;
                    // 数据库密码
                    std::string db_test_pwd;
                    // 数据库名称
                    std::string db_test_name;
                    // 数据服务器Ip
                    std::string server_ip;
                    // 数据服务器Port
                    int server_port;
                    // 发送报警信息的链接
                    std::string warming_url;
                    // 发送报警信息的加密字符
                    std::string warming_token;
                    // 根目录
                    std::string root_path;
                    // mqtt_host
                    std::string mqtt_server_host;
                    // mqtt_username
                    std::string mqtt_username;
                    // mqtt_password
                    std::string mqtt_password;
                    // mqtt发布主题
                    std::string mqtt_pub_topic;
                    // mqtt订阅主题
                    std::string mqtt_sub_topic;
                };

                /**
                 * @brief 加油交易数据实体.
                 *
                 * Detailed explanation.
                 */
                struct OilTransaction
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 设备唯一编号（油站编码+lora_id）
                    std::string device_code;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 加油机编码
                    std::string device_number;
                    // 报税口号
                    std::string tax_code;
                    // lora芯片id
                    // uint16_t lora_id;
                    uint16_t lora_id;
                    // 枪号
                    // uint8_t nozzle_code;
                    uint8_t nozzle_code;
                    // 抬枪时间
                    uint32_t beg_time;
                    // 挂枪时间
                    uint32_t end_time;
                    // 开始加油时间
                    uint32_t trans_beg_time;
                    // 结束加油时间
                    uint32_t trans_end_time;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 期望加油量
                    int expect_volume;
                    // 加油量
                    int volume;
                    // 单价
                    int price;
                    // 交易金额
                    int amount;
                    // 编码器数值
                    uint32_t encoder_val;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                    // 显示屏数据类型
                    uint8_t screen_raw_type;
                    // 显示屏类型
                    uint8_t screen_type;
                    // 屏显原始数据
                    std::string screen_raw_data;
                    // 转换率
                    uint16_t rate;
                };

                struct OilTransRawData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 加油机编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 抬枪时间
                    uint32_t beg_time;
                    // 挂枪时间
                    uint32_t end_time;
                    // 加油量
                    int volume;
                    // 交易金额
                    int amount;
                    // 编码器数值
                    uint32_t encoder_val;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-正常; 9-异常
                    uint8_t sort;
                    // 错误类型
                    uint8_t data_type;
                    // 金额偏离度
                    int amount_deviation;
                    // 油量偏离度
                    int vol_deviation;
                    // 显示屏数据类型
                    uint8_t screen_raw_type;
                    // 显示屏类型
                    uint8_t screen_type;
                    // 屏显原始数据
                    std::string screen_raw_data;
                    // 转换率
                    uint16_t rate;
                    // 0-未处理;1-已处理
                    uint8_t status;
                };

                struct OilTransRawCount
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                };

                /**
                 * @brief 加油交易数据日汇总表.
                 * group by: days, station_code, category
                 *
                 * Detailed explanation.
                 */
                struct OilTransByDays
                {
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 期望加油量
                    int expect_volume;
                    // 加油量
                    int volume;
                    // 期望交易金额
                    int expect_amount;
                    // 交易金额
                    int amount;
                    // 交易次数
                    int trans_counts;
                    // 编码器数值
                    uint32_t encoder_val;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct ScreenData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 加油量
                    int volume;
                    // 单价
                    int price;
                    // 交易金额
                    int amount;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                    // 显示屏数据类型
                    uint8_t screen_raw_type;
                    // 显示屏类型
                    uint8_t screen_type;
                    // 屏显原始数据
                    std::string screen_raw_data;
                };

                struct ScreenDataByDays
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct ScreenDataByMonths
                {
                    // 月数，以数字形式呈现（202408）
                    uint32_t months;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct TaxData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 加油量
                    int volume;
                    // 单价
                    int price;
                    // 交易金额
                    int amount;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                };

                struct TaxDataByDays
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 交易次数
                    uint32_t trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct TaxDataByMonths
                {
                    // 月数，以数字形式呈现（202408）
                    uint32_t months;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    int32_t last_update_time;
                };

                struct EncoderData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 加油量
                    int volume;
                    // 单价
                    int price;
                    // 交易金额
                    int amount;
                    // 编码器数值
                    uint32_t encoder_val;
                    // 创建时间
                    int32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                };

                struct EncoderDataByDays
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 编码器数值
                    int32_t encoder_val;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct EncoderDataByMonths
                {
                    // 月数，以数字形式呈现（202408）
                    uint32_t months;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 加油量
                    int32_t volume;
                    // 交易金额
                    int32_t amount;
                    // 编码器数值
                    int32_t encoder_val;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    int32_t last_update_time;
                };

                struct NozzleTimeData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_lora芯片id_枪号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 抬枪时间
                    int32_t beg_time;
                    // 挂枪时间
                    int32_t end_time;
                    // 创建时间
                    int32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                };

                struct NozzleTimeDataByDays
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct NozzleTimeDataByMonths
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t months;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 交易次数
                    int trans_counts;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct PriceInfo
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 序号
                    int sn;
                    // 区域Id
                    std::string dept_id;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 交易金额
                    int price;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                };

                struct OilTankData
                {
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 序号
                    uint8_t tank_code;
                    // 油品
                    uint8_t category;
                    // 当前油高
                    double oil_level;
                    // 当前水高
                    double water_level;
                    // 当前温度
                    double temperature;
                    // 当前油容积
                    double oil_volume;
                    // 当前油容积
                    double water_volume;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct OilTankTransData
                {
                    // 全球唯一码
                    std::string guid;
                    // 交易Id (获取数据的时间戳_油站编码_油管序号)
                    std::string trans_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 序号
                    uint8_t tank_code;
                    // 油品
                    uint8_t category;
                    // 当前油高
                    double oil_level;
                    // 当前水高
                    double water_level;
                    // 当前温度
                    double temperature;
                    // 当前油容积
                    double oil_volume;
                    // 当前油容积
                    double water_volume;
                    // 油高增量
                    double oil_level_increment;
                    // 油体积增量
                    double oil_vol_increment;
                    // 日期天
                    uint32_t days;
                    // 创建时间
                    uint32_t create_time;
                    // 数据类型 0-系统录入; 1-人工补录
                    uint8_t sort;
                };

                struct OilTankDataByDays
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t days;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 油罐编号
                    uint8_t tank_code;
                    // 出油高度
                    double oil_level_out;
                    // 出油体积
                    double oil_vol_out;
                    // 进油高度
                    double oil_level_in;
                    // 进油体积
                    double oil_vol_in;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct OilTankDataByMonths
                {
                    // 日期，以数字形式呈现（20240812）
                    uint32_t months;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 油罐编号
                    uint8_t tank_code;
                    // 出油高度
                    double oil_level_out;
                    // 出油体积
                    double oil_vol_out;
                    // 进油高度
                    double oil_level_in;
                    // 进油体积
                    double oil_vol_in;
                    // 最新更新时间
                    uint32_t last_update_time;
                };

                struct NozzleConfigInfo
                {
                    // 加油枪Id
                    std::string gun_id;
                    // 油站编码
                    std::string station_code;
                    // 区域Id
                    std::string dept_id;
                    // 油站编码
                    std::string device_number;
                    // 区域Id
                    std::string tax_code;
                    // lora芯片id
                    uint16_t lora_id;
                    // 枪号
                    uint8_t nozzle_code;
                    // 油品 0, 92, 95，98
                    uint8_t category;
                    // 屏幕类型
                    uint8_t screen_type;
                    // 编码器数值，转换率
                    uint16_t rate;
                    // 最新更新时间
                    uint32_t last_update_time;
                };
            }
        }
    }
}

#endif